interface SeqListInterface{
    
    public Object get(int i);

    public void print();

    public boolean isEmpty();

    public int insert(int x) ;

    public int insert(int i, int x);

    public Object remove(int i, int k);

    public int insertSort(int x);

    public void autoBuild(int i, int limit);

    public void autoBuildSort(int i, int diff, int noise) ;
}

public class SeqList extends Object implements SeqListInterface{

    /***
     * 1.从顺序表中删除自第i个元素起共k个元素。 2.顺序表元素递减有序，将x插入顺序表中，保持其有序性。
     ***/

    // 顺序表定义
    protected int n; // 长度
    protected Object[] element; // 数据元素存储器
    private static final int MIN_CAPACITY = 16; // 最小容量

    // 有参构造
    public SeqList(int length) {
        if (length < MIN_CAPACITY) {
            length = MIN_CAPACITY;
        }
        this.element = new Object[length];
        this.n = 0;
    }

    // 无参构造
    public SeqList() {
        this(MIN_CAPACITY);
    }

    // 查询
    public Object get(int i) {
        return this.element[i];
    }

    // 打印输出
    public void print() {
        for (int i = 0; i < this.n; i++) {
            System.out.print(this.get(i) + "\t");
        }
        System.out.println();
    }

    public boolean isEmpty() {
        return this.n == 0;
    }

    // 向末端插入元素
    public int insert(int x) {
        return this.insert(this.n, x);
    }

    public int insert(int i, int x) {
        // 原有顺序表继承
        Object[] sorce = this.element;
        // 扩容判定与处理
        if (this.n == this.element.length) {
            this.element = new Object[this.element.length * 2];
        }
        // 原顺序表i之前数据数据还原
        for (int j = 0; j < i; j++) {
            this.element[j] = sorce[j];
        }
        // i之后的倒序数据还原
        for (int j = n; j > i; j--) {
            this.element[j] = sorce[j - 1];
        }
        // i插入
        this.element[i] = x;
        n++;
        return 1;
    }

    public int insertSort(int x) {
        int i = 0;
        while (x > (int) this.element[i]) {
            i++;
        }
        insert(i, x);
        return i;
    }

    // 自动顺序表生成(测试用)
    public void autoBuild(int i, int limit) {
        // 根据参数随机生成一定长度的顺序表
        for (int j = 0; j < i; j++) {
            int n = (int) (Math.random() * limit);
            this.insert(n);
        }
        this.print();
    }

    // 自动有序顺序表生成（测试用）(采用噪音生成器完成)
    public void autoBuildSort(int i, int diff, int noise) {
        // 根据参数随机生成一定长度的顺序表
        int p;
        this.insert(p = (int) ((Math.random() * noise * Math.random())));
        for (int j = 0; j < i - 1; j++) {
            int n = (int) (Math.random() * diff + p);
            p = n;
            this.insert(n);
        }
        this.print();
    }

    // 1.从顺序表中删除自第i个元素起共k个元素
    public Object remove(int i, int k) {
        if (i >= 0 && i + k <= n) {
            // 保存将要删除的元素
            Object[] del = new Object[k];
            int del_n = 0;
            for (int j = i; j < i + k; j++) {
                del[del_n] = this.element[i + j];
                del_n++;
            }
            // 数据覆盖
            for (int j = i; j < i + k; j++) {
                this.element[j] = this.element[j + k];
            }
            // 真删除部分，将完全删除，可省略，省略为伪删除
            for (int j = n; j > n - k; j--) {
                this.element[j] = null;
            }
            // n值调整
            n = n - k;
            System.out.println("done，delted part will be returned");
            // 返回删除的部分
            return del;
        } else {
            System.out.println("error,please check the number of your input in law");
            return null;
        }
    }
    

}